// ���������� STL: 
//stack, queue, priority_queue
//set, multiset, map, multimap

#include "stdafx.h"

#include <iostream>
#include "Header.h"

using namespace std;

#define stop __asm nop

int _tmain(int argc, _TCHAR* argv[])
{


	//�������� ������ ������� ��� ������ �������� stack, queue, priority_queue
	//�������� �������� �� ��, ��� ���������� ������������� ������ ������ ��� 
	//��������� ��������
	{
		deque<int>d{ 0,1,2,3,4,5,6 };
		stack<int> s_int(d);

		print_adapter(s_int);

		deque<string>d1{ "zero", "one", "two", "three" };
		queue<string>q_str(d1);

		print_adapter(q_str);

		vector<string>v{ "www", "ttt", "AAA", "kkk", "aaa", "WWW", "TTT", "KKK" };
		priority_queue<string>p_q_str(v.begin(), v.end());

		print_adapter(p_q_str);
		stop
	}

	std::cout << std::endl;
	////////////////////////////////////////////////////////////////////////////////////
	//stack

	//�������� ���� ����� �������, �����
	//�) �������� ����� ����� ������� ��������� �������
	//�) ��� ������ �������� ��� �������, ��� � ����� ������� �������� ��� ���������� 
	{
		vector<int>v1{ 0, 1, 2, 3, 4, 5, 6 };
		print_container(v1);

		stack<int, vector<int>>st_v_int;
		for (int i = v1.size() - 1; i >= 0; i--)
		{
			st_v_int.push(v1[i]);
		}
		print_adapter(st_v_int);

		stop
	}
	std::cout << std::endl;
	////////////////////////////////////////////////////////////////////////////////////
	//queue

	//�������� �������, ������� �������� ��������� �� ������� ���� Point,
	//��� ���� ���� ������� ������� ���������.
	//�������� �������� ������� � ���������� ��������� ����������� front() � back()
	
	{
	queue<Point*, deque<Point*>>d_pointptr;
	for (double i = 0; i < 4.; i++)
	{
		d_pointptr.push(new Point(i + 10.0, i));
	}
	print_adapter(d_pointptr);

	d_pointptr.front()->Set_All(1, 2);
	d_pointptr.back()->Set_All(7, 7);
	print_adapter(d_pointptr);
	
	//���������, ��� ��������� ������� ��� ����������� ����� �������?
	while (!d_pointptr.empty())
	{
		delete[] d_pointptr.front();
		d_pointptr.pop();
	}
	}
	stop
	std::cout << std::endl;
	////////////////////////////////////////////////////////////////////////////////////
	//priority_queue
	//�) �������� ������� � ������������, ������� ����� ������� ������ ��������� ��������� - const char*
	//�) ������������������ ������� ��� �������� � ������� ���������������� ������� � ���������� const char*
	
	{
	const char* ar[]{ "www", "ttt", "AAA", "kkk", "aaa", "WWW", "TTT", "KKK" };
	priority_queue<const char*/*, deque<const char*>,comp*/>pr_d(ar, ar + sizeof(ar) / sizeof(ar[0]));
	//�) ��������� "���������������" �������� (� ������� pop() ) 
	print_adapter(pr_d);

	pr_d.pop();
	print_adapter(pr_d);
	// ���� ��� ����������� �� ��������������, ���������: ��� ������������ ��� �������?
	
	//������, �������� ���������������� ���������� ��� ��������� �����(����������������)
	stop
	}
	std::cout << std::endl;
	
	////////////////////////////////////////////////////////////////////////////////////
	//set
	//a) �������� ��������� � ���������� ���� Point - ���������, ��� ���������� ����������
	//		� ������ Point (� ����� �������)
	//�) ������������ �������� ��������� � ������� �������, �������������� � ���������� ���. ������
	//�) ���������� �������� ����� ��������...
	//�) �������� ��� ���������, ������� ����� ��������� ���������� �������� ���� int, �� ���������� � ������ �������
	//�) �������� � ����� ��������� �������� ��������� �� ������ �������
	//	����������, ��������, ��������� �������	(��� ����������, ���� � ������� ������� �����?)
	{
	set<Point>s_p;
		for (double i = 5; i >1.; i--)
		{
			s_p.insert(Point(i-1.0, i));
		}
	print_container(s_p);

	typename set<Point>::const_iterator it_b = s_p.begin();
	//(*it_b). �������� �������� ����������, ��� �������� ��� ���������. ���������� ������� ����� Set_All, �.�. ����� �� �����������, �� ����������� ��� ������ ��� ������
	
	
	vector<int> vec{ 0,1,1,1,2,3,3,4,5,8,5,9,45,17,45 };
	
	set<int>s_int1(vec.begin(), vec.end());
	print_container(s_int1);
	set<int,greater<int>>s_int2(vec.begin(), vec.end());
	print_container(s_int2);
	
	int arr[]{44,44,52,1,0,44,44,89,55,89,11};
	s_int1.insert(arr + 2, arr + 8);
	print_container(s_int1);

	//�������� ���������, ����� ������������, set ����������� � ������������ � ��������� ���������������(�� ��������� less)
	stop
	}

	std::cout << std::endl;

	////////////////////////////////////////////////////////////////////////////////////
	//map, multiset
	//�) �������� map, ������� ������ ���� "�������, ��������" - pair<const char*, int>,
	//	��� ���� ������ �������� ���������� ����������
	//�) ��������� ��������� ���������� ����������� operator[] � insert()
	//�) ������������ ����������

	{
		map<const wchar_t*, int> salary1;

		salary1[L"�������"] = 50000;
		salary1[L"������"] = 30000;
		salary1[L"�������"] = 10000;
		salary1[L"�������a"] = 15000;

		salary1.insert(pair<const wchar_t*, int>(L"�������", 55000));//insert �� ������������ �������� 
		salary1.insert(pair<const wchar_t*, int>(L"������", 5000));
		salary1.insert(pair<const wchar_t*, int>(L"�����", 15000));
		salary1.insert(pair<const wchar_t*, int>(L"���������", 11000));
	
		setlocale(LC_ALL, "Russian");
		print_associative_container(salary1);
	
		//�) �������� ���� �� ������ �� ����� (���� "�������", ����� ����� => ����� "�������")
		
		//(*salary1.find(L"�������")).first = L"�������"; //����� �������� ��� ���������!
		//	Error(active)	E0137	expression must be a modifiable lvalue	
		//������� ��������, ������������ ������
		//����� �������������� ��������
		if (salary1.find(L"�������")!= salary1.end())
		{
			(*salary1.find(L"�������")).second = 55000; 
		}
		
		//������ ��������:
		salary1[L"�������"] = (*salary1.find(L"�������")).second;
		salary1.erase(L"�������");
		print_associative_container(salary1);
		
		stop
		
		//�) ����������� ����� �������� ������ � ���������� ���� string.
		//�������� (� ������������ ��� ��������) map<string, int>, ������� �����
		//��������� ������������� �� �������� ������ �
		//���������� ���������� ������ ������ � �������
	
		vector<string> v_str{"www","KKK", "ttt", "AAA", "kkk", "aaa", "WWW", "TTT", "KKK", "AAA", "AAA"};
		map<string, int> m_s_i;

		vector<string>::iterator it_b = v_str.begin(), it_end = v_str.end();
		while (it_b != it_end)
		{
		//	bool fl = m_s_i.insert(pair<string, int>(*it_b, 1)).second;
			/*if (!fl)*/ ++m_s_i[*it_b];
			++it_b;
		}
		print_associative_container(m_s_i);
		
		stop
		
		//�) 
		//����� ������:
		const char* words[] = {"Abba", "Alfa", "Beta", "Beauty"};
		//�������� map, � ������� ������ ����� ����� ��������������� ������������ 
		//��������������� ������������� ����, ������������ � ���� �����.
		//���������: �� ����� ������� ����� ����� � ��� �� ������
		
		//'A' -  "Abba" "Alfa"
		//'B' -  "Beauty" "Beta"  ...
		//...
		
		map<char, set<string>> m_ch_str;

		int n = sizeof(words) / sizeof(words[0]);
		for (int i = 0; i < n; i++)
		{
			char x = toupper(*words[i]);
			m_ch_str[x].insert(words[i]);
		}
		print_associative_container(m_ch_str);
	
		stop

		//�)
		//�������� ��������� ������, ������� ����� ������� ���������� � ������������ �������.
		//��� ������ ������ ������ �������� ������� ��������� (�� ��������). ��� ���� 
		//������� ����� �������������
		//���� ������ ���� ������ ���� ����������� �� ������
		//
		//������ 

		string groups[] = { "W_101DD", "A_102DD", "D_103DD" };
		string students[]{ "������","������","�������","��������","������","�����","�������","�����","������","������","�����","����" };

		map<string, multiset<string>> m_int_multiset;

		const int N1 = sizeof(groups) / sizeof(groups[0]);
		const int N2 = sizeof(students) / sizeof(students[0]);
		int i = 0;

		for (int j = 0; j < N1; j++)
		{
			for (int k = 0; k < N2/ N1; k++)
			{
				m_int_multiset[groups[j]].insert(students[i]);
				i++;
			}
		}
		print_associative_container(m_int_multiset);
		stop
	}
	
	////////////////////////////////////////////////////////////////////////////////////
	//multimap
	//�) �������� "�����-�������" �������, ��� ������ � ���� �� ����� ����� ���������������
	//		��������� ������� �������� - pair<string,string>, ��������: strange: �����, ��������...
	//�) ��������� ������� ������ � ������� ������ insert ��� ������������������ � ������� 
	//		���������������� ������� ���� (���� ����� �������������� ��� ��������� � ������� ������� make_pair)
	//�) �������� ��� ���������� ������� �� �����
	//�) �������� �� ����� ������ �������� "���������" ��� ��������� �����. ���������: ��� ���������� ���������
	//		���������� ����� ������������ ������ lower_bound() � upper_bound()
		
	pair<string, string> words[]={ make_pair("strange","�����"),make_pair("strange","��������"),
		make_pair("strange","����������"),make_pair("ash","�����"),make_pair("ash","�����"),make_pair("water","����"),
		make_pair("water","�����"), make_pair("principle","������"), make_pair("principle","�������"),
		make_pair("principle","�������"), make_pair("principle","��������")};
	
	multimap<string, string>vocabulary{ words ,words + sizeof(words) / sizeof(words[0]) };
	print_associative_container(vocabulary);
	
	/*multimap<string, string>::const_iterator ITvoc_b = vocabulary.find("principle");
	int x = vocabulary.count("principle");*/

	multimap<string, string>::const_iterator itt = vocabulary.lower_bound("principle");
	multimap<string, string>::const_iterator itend = vocabulary.upper_bound("principle");

	while (itt != itend)
	{
		std::cout << (*itt).first << ":" << (*itt).second << " ";
		std::cout << std::endl;
		++itt;
	}

	/*for(int i=0; i< x; i++)
	{
		std::cout << (*ITvoc_b).first << ":" << (*ITvoc_b).second << " ";
		std::cout << std::endl;
		++ITvoc_b;
	}*/
	std::cout << std::endl;
	
	stop

	return 0;
}

